Metric payload ingestion and replay

ABSTRACT

In one aspect, a method for metric payloads ingestion and playback is disclosed. The method includes receiving time series of metric payloads for a plurality of performance metrics indicating performance of a node or machine and storing the received time series of metric payloads in a payload tracking table of a database. The storing includes storing the received time series of metric payloads in different layers and partitioned regions of the payload tracking table. The layers represent time ranges corresponding to time points when the time series of metric payloads are received. The partitioned regions are assigned to received certain ones of the received time series of metric payloads. The method includes replaying the stored time series of metric payloads from a select one or more of the partitioned region or layer or both.

BACKGROUND

In pursuit of the highest level of service performance and user experience, companies around the world are engaging in digital transformation by enhancing investments in digital technology and information technology (IT) services. By leveraging the global system of interconnected computer networks afforded by the Internet and the World Wide Web, companies are able to provide ever increasing web services to their clients. The web services may be provided by a web application which uses multiple services and applications to handle a given transaction. The applications may be distributed over several interconnected machines, such as servers, making the topology of the machines that provide the service more difficult to track and monitor.

SUMMARY

Examples of implementations for metric payload ingestion and replay using distributed micro services architecture is disclosed. Specifically, the disclosed technology can enable ingestion of metric payloads using a distributed micro services and persisting the payload into a distributed database, such as HBase, so that the payload data persisting in the database can be replayed for any given time period.

In one aspect, a method for metric payloads ingestion and playback is disclosed. The method includes receiving time series of metric payloads for a plurality of performance metrics indicating performance of a node or machine and storing the received time series of metric payloads in a payload tracking table of a database. The storing includes storing the received time series of metric payloads in different layers and partitioned regions of the payload tracking table. The layers represent time ranges corresponding to time points when the time series of metric payloads are received. The partitioned regions are assigned to received certain ones of the received time series of metric payloads. The method includes replaying the stored time series of metric payloads from a select one or more of the partitioned region or layer or both.

The method can be implemented in various ways to include one or more of the following features. For example, the method can include receiving a request to replay the stored time series of metric payloads for a specific one of the layers; and performing the replaying for the specific one of the layers based on the received request to replay. The received request to replay can be associated with a repair job to repair data corruption. The specific one of the layers can represent a time range associated with the data corruption. The method can include outputting a result of the replay. The method can include outputting a result of the replay to the repair job. The method can include performing the repair job using the outputted result. The partitioned regions can be created using a hash function. The database can include HBase.

In another aspect, a system for metric payload data ingestion and playback is disclosed. The system includes collectors to receive, time series metric payloads for performance metrics from one or more agents instrumented into monitored applications. The system includes aggregators communicatively connected to the collectors to aggregate the received time series metric payloads for the performance metrics. Each aggregator is assigned to aggregate all received time series metric payloads for one or more of the plurality of performance metrics. The system includes a coordinator communicatively connected to the collectors and aggregators to provide collectors with information on the aggregators including assignments of the performance metrics to each aggregator. The system includes a database including a payload tracking table for storing the received time series metric payloads.

The system can be implemented in various ways to include one or more of the following features. For example, the payload tracking table can include different layers having partitioned regions. The layers represent time ranges corresponding to time points when the time series of metric payloads are received. The partitioned regions are assigned to received certain ones of the received time series of metric payloads. The payload tracking table can replay the stored time series of metric payloads from a select one or more of the partitioned region or layer or both. The payload tracking table can replay the stored time series of metric payloads responsive to a request to replay the stored time series of metric payloads for a specific one of the layers. The request to replay can be associated with a repair job to repair data corruption. The specific one of the layers can represent a time range associated with the data corruption. The partitioned regions can be created using a hash function. The database can include HBase.

In another aspect, a non-transitory computer readable medium embodying instructions when executed by a processor to cause operations to be performed is disclosed. The operations caused include receiving time series of metric payloads for a plurality of performance metrics indicating performance of a node or machine. The operations caused include storing the received time series of metric payloads in a payload tracking table of a database. The storing includes storing the received time series of metric payloads in different layers and partitioned regions of the payload tracking table. The layers represent time ranges corresponding to time points when the time series of metric payloads are received. The partitioned regions are assigned to received certain ones of the received time series of metric payloads. The operations caused include replaying the stored time series of metric payloads from a select one or more of the partitioned region or layer or both.

The non-transitory computer readable medium can be implemented various ways to include one or more of the following features. For example, the operations can include receiving a request to replay the stored time series of metric payloads for a specific one of the layers; and performing the replaying for the specific one of the layers based on the received request to replay. The received request to replay can be associated with a repair job to repair data corruption. The specific one of the layers can represent a time range associated with the data corruption.

BRIEF DESCRIPTION OF THE DRAWINGS

FIGS. 1A and 1B are diagrams illustrating an exemplary payload tracking table.

FIG. 2 is a process flow diagram showing an exemplary process for metric payload ingestion and playback as disclosed in this patent document.

FIGS. 3A and 3B are process flow diagrams showing an exemplary technique for distributed metric data time rollup in real-time.

FIGS. 4A and 4B are block diagrams illustrating time rollup of distributed metric data from granular raw data to progressively less granular data.

FIGS. 5A and 5B are block diagrams of tables illustrating exemplary metric key time buckets for rolling up raw data to progressively less granular data.

FIG. 5C is an exemplary metric key.

FIG. 6 is a block diagram of an exemplary system for performing distributed metric data time rollup in real-time.

FIG. 7A is a process flow diagram of a process for scaling the nodes of aggregators by adding a new aggregator to the ring.

FIG. 7B is a block diagram illustrating an addition of a new aggregator described in process of FIG. 7A.

FIG. 7C is a process flow diagram of the process for fixing or preventing data corruption.

FIG. 7D shows an exemplary column with two cells from two aggregators.

FIG. 8A is a process flow diagram of a process for scaling the nodes of aggregators by removing an aggregator to the ring.

FIG. 8B is a block diagram illustrating the removal of the aggregator described in process of FIG. 8A.

FIG. 8C is a process flow diagram of the process 808 for fixing or preventing data corruption due to the removed aggregator.

FIG. 8D shows an exemplary column 830 with the two cells.

FIG. 9A is a process flow diagrams of a process for repairing metric data after an aggregator crashes.

FIG. 9B is a block diagram illustrating a crashed aggregator in a consistent hash ring of aggregator nodes.

FIG. 9C is a process flow diagram of a process for performing the repair job.

FIG. 9D is a process flow diagram of a process for preparing for the repair job so that the repair job when performed is optimized.

FIG. 9E is a block diagram illustrating buckets created during the repair job preparation process.

FIG. 9F is a process flow diagram showing an exemplary process for performing a repair job after a crash once the preparation for the repair job has been integrated into the process.

FIG. 10 is a block diagram of an exemplary application intelligence platform that can implement the metric payload ingestion and replay techniques using the disclosed technology, including the processes disclosed with respect to FIGS. 1A through 9F.

FIG. 11 is a block diagram of an exemplary implementation of the application intelligence platform for metric payload ingestion and replay techniques using the disclosed technology.

FIG. 12 is a block diagram of an exemplary computing system implementing the disclosed technology.

DETAILED DESCRIPTION

Application intelligence platforms disclosed in this patent document enable application performance monitoring and management using metrics driven processes and systems. In the disclosed application intelligence platforms, monitoring of the raw application performance time series payload data is performed by highly efficient instrumentation agents that have automatic code injection capability to trace virtually every line of codes in a given application. These agents automatically instrument millions of lines of code across thousands of tiers, in production environments. The agents support a wide variety of languages and frameworks including java, .Net, Node.js, PHP, Ruby etc. In addition, the disclosed application intelligence platforms include browser and mobile agents to collect end user monitoring information from browser or any mobile devices.

The agents collect the time series metrics payload data indicative of a number of application performance measures and send the collected time series metrics data periodically to a metric processing engine at a collector. The metric processing engine rolls up or aggregates the metrics in different dimensions and creates multiple views. The created views are extensively used for reporting and rule engine evaluation for health rule policies.

The created views can include at least two types, hierarchical cluster rollup view and time rollup view. In this patent document, the disclosed technology can enable the time rollup views. Time rollups are performed by rolling up and aggregating raw granular (e.g., 1-minute interval) time series data into progressively less granular data. For example, the raw 1-minute time series data can be rolled up into 10-minute buckets (e.g., by averaging the 1-minute interval data every 10 minutes). The rolled up 10-minute buckets can be rolled up into hourly buckets (e.g., by averaging every six 10-minute buckets into each hourly bucket). The rolled up hourly buckets can be rolled up into daily buckets (e.g., by averaging every twenty-four 1-hour buckets into each daily bucket. The rolled up daily buckets can be rolled up into weekly buckets (e.g., by averaging every seven daily buckets into each weekly bucket). The rolled up weekly buckets can be rolled into monthly buckets (e.g., by averaging every 4 weekly buckets into each monthly bucket). The rolled up monthly buckets can be rolled into yearly buckets (e.g., by rolling up every 12 monthly buckets into each yearly bucket). In some implementations, other granularities in the metrics rollup can be used.

The volume of performance metrics monitored and collected by the agents is extremely high resulting in storage resource burdens. For example, the total number of performance metrics collected per minute by an agent from a large application can be in the range of 10 to 20 million data points. Because each performance metric has several performance statistics, everyday system can ingest 2 to 4 TB of data. Storing the high-resolution (e.g., per minute) data for a long time is not practicable and cost prohibitive. One solution to address the storage burden is to expire the highest resolution data after some period. In order to provide access to the performance metrics for a much longer period of time, the high resolution performance metrics are rolled up into lesser resolutions (e.g., hourly, daily, weekly, monthly, yearly). Also, a health rule policy engine can be used to evaluate data based on baseline and start deviation statistics for a longer a period of time.

Metric Payload Ingestion and Replay Using Distributed Micro Services

The disclosed technology for metric payload ingestion and replay using distributed micro services stores the time series metric payload data in a payload tracker table created in a distributed database, such as HBase. FIGS. 1A and 1B are representations of an exemplary payload tracker table 100. The payload tracker table 100 is partitioned into multiple regions. In the example shown in FIG. 1A, the table 100 is partitioned into 26 regions corresponding to index names A through Z. The 26 partitioned regions of the table 100 is generated using a hashing function with mod 26. Thus the number of partitioned regions can vary by using different hashing functions as needed or desired.

The payload tracker table 100 can be created in a distributable and scalable database, such as HBase. As shown in FIG. 1A, the payload tracker table 100 can be visualized as a cylinder that gets filled with incoming time series payloads layer by layer (t10, t9, t8, . . . ) with each layer representing a time range. The circumference of the cylinder is divided into multiple partitions (e.g., 26 partitions), and each partitioned is filled by payload coming from different nodes or machines as shown in FIG. 1B. In FIG. 1B, one time slice layer 102 is shown for illustrative purposes. For example, partition A stores payloads P3, P25 and, P82. The partition B stores payloads P2, P4, and P19. The partition C stores payloads P7, P8, and P9. The partition D stores payloads P1, P12, and P18. The specific payloads stored in each partition can depend on the distribution of the payloads by the metric processing system, which is further described with respect to FIG. 4 below.

The payload tracker table 100 can be implemented to provide certain functionalities. For example, time series metric payload data stored in the payload tracker table 100 can be distributed in a cluster, and there should not be any hot spots. The payload tracker table 100 can be queried by time index, such as a time range query from t1 to t2. The payload tracker table 100 can expire stored data to clean up space for receiving new time series payload data.

Key to Payload Tracker Table

A key to the payload tracker table 100 can be designed to include a prefix salt indicating the partition, a time indicator, and node information: Prefix salt [A . . . Z]+time+node info

The prefix salt in the kay is calculated by applying a hash function to the node ID, and applying mod 26 on the hash code. The resultant number is used as an index to a char array with prefix salt from [A to Z]. The time indicator of the key is bucketed every time interval (e.g., every hour) and the node info portion of the key is the node or machine ID that sent the payload. The payload information can be stored as values against column names that have the time at which the payload arrived.

Table 1 shows an exemplary key for the payload tracking table 100.

Key Values [B][10:00 am 10 Jan 2016] Column 10:01 10:02 . . . 10:59 [Node-102] Name Value P1 P2 . . . P60 [B][11:00 am 10 Jan 2016] Column 11:01 11:02 . . . 11:59 [Node-102] Name Value P61 P62 . . . P120

Payloads coming from other nodes may end up in different partitioned region of the payload tracking table 100 based on the hash function. As the payloads coming into the metric processing system are distributed across the multiple (e.g., 26) partitioned regions, the disclosed payload tracking table 100 prevents hot spots in the cluster.

The total number of payloads received from time t1 through t2 can be determined by performing 26 queries to the payload tracking table 100. For example, the first query can be constructed as follows:

-   -   Start Key: A+Start time of the time range rolled up to the last         hour     -   End Key: A+End time of the time range rolled up to the last hour     -   Filter by time range: t1 to t2

The above query can be repeated for 25 more times by using different prefix salts [B to Z]. Thus, each query searches for each partitioned region for the time range t1 to t2.

In addition to allowing for the cleanup of the storage space, the data retention period can allow for the stored payload data to be replayed for the purpose of repairing any data corruption. For example, a TTL can be set at a column family of the payload tracking table 100 as the data retention period to expire the data after 24 hours. The 24-hour retention period allows the data to be replayed for the 24-hour period and repair any data corruption for the 24-hour period. The retention period can be customized to control the replay capability, which affects the data corruption repair capability.

The payload tracking table 100 as disclosed in this patent document can allow queries for the payload data per time range and per partition. For example, when queried per time range, all payloads received in all partitioned regions during the queried time range are returned. When queried per partition region, all payloads stored in the requested partitioned region for all time ranges can be returned. Because each partitioned region can be assigned to specific nodes or machines, the ability to query by the partitioned region allows the metric system to return payload data for specific nodes or machines in addition to time specific payload data.

Exemplary Methods for Metric Payload Ingestion and Playback

FIG. 2A is a process flow diagram showing an exemplary method 200 for performing metric payload ingestion and playback as disclosed in this patent document. Time series metric payload data are received at process 202. The received metric payload data are time series data received at each time interval (e.g., every 1-minute) and thus provides a high resolution data. The 1-minute resolution time series data are processed by a metric processing system (e.g., metric processing system 400 of FIG. 4) and time rolled up. The received time series metric payload data are stored in different partitioned regions of a payload tracking table at process 204. See FIG. 1B and corresponding description for an example of storing different payloads in different partitioned regions of the payload tracking table 100.

When a repair job is detected at process 206, the payload data stored in the payload tracking table is replayed using one or more queries for a time range associated with corrupted data to be repaired at process 208. A repair job can be necessary when a node aggregating the payload data fails. The number of queries for the repair job can depend on the number of partitioned regions affected by the corrupted data. The metric payload data received from the replay are filtered for specific payload or payloads associated with the corrupted data at process 210. The filtered payload data is returned to perform the requested repair job at process 212.

Exemplary Advantages

The disclosed technology for performing metric payload ingestion and replay enables replay of the incoming time series metric payloads to the metric processing system in the event of any node failure in the stream-processing pipeline of the metric processing system. The disclosed metric payload ingestion and replay technique can enable metric processing system to operate in real time and become fault tolerant. Also, the disclosed metric payload ingestion and replay mechanism allows HBase infrastructure to be used as a persistent queue, eliminating the use of other expensive persistent queuing mechanism, reducing the cost of hosting of the entire metric processing system.

Distributed Consistent Hash Backed Metric Time Rollup Techniques

The disclosed techniques for time series metric payload ingestion and playback can be implemented in a metric processing system to perform distributed consistent hash backed metric time rollup. Table 2 below shows an exemplary data retention policy for different time rollup resolution of performance metrics.

TABLE 2 Exemplary data retention policy for different resolution of performance data Metric Resolution Retention Period  1 minute 1 day 10 minutes 8 days 60 minutes 1 year

For performance time series metrics data collection rate of one per each minute, each agent can collect 10 performance metrics data points over a period of 10 minutes, and performance time series metrics 60 data points over a period of 60 minutes. Using the data retention policy of Table 1, the system will continuously rollup the 1-minute resolution metrics to 10-minutes resolution every 10 minutes, and then to 60-minutes resolution every hour. The rollup process is performed for every metric collected by the agents from the application monitored by the agents. End users can access the collected metrics data by using queries that identifies a metric ID and a time range. Depending on the time range requested, different rollup of the collected data may need to be performed. For example, when the time range specified is within 24 hours, the 1-minute resolution data (i.e., the raw collected metrics data) can be returned. When the time range specified is within 8 days the 10-minute resolution data (i.e., 1-minute resolution data rolled up every 10 minutes) can be returned. When the time range specified is beyond 8 days, the 60-minute resolution data (e.g., the 10-minute resolution data rolled up every 60 minutes) can be returned.

The time series metrics payloads are processed and aggregated in stream in real time and aggregated to create multiple views, using distributed micro services. Any anomaly caused at the stream services may corrupt the aggregated data views. The corrupt views can be repaired immediately by replaying the payloads on the stream processing services. The payloads can be replayed by persisting the payloads for certain time and can be queried by a time range using the time series metric payload ingestion and replay techniques disclosed above with respect to FIGS. 1A, 1B and 2. The disclosed technology can provide for a payload ingestion mechanism that can persist the payload data in real time and replay the payload at any given time. Also, the persisted payload data can be expired from the system after a retention period to make space for new time series payload data arriving at the system.

FIGS. 3A and 3B are process flow diagrams of exemplary technique for performing distributed consistent hash backed metric time rollup in real time using read time resolution. The techniques disclosed in FIGS. 3A and 3B are performed by a metrics processing system as disclosed with respect to FIGS. 6A, 6B, and 6C. As shown in FIG. 3A, the technique 300 for distributed consistent hash backed metric time rollup includes receiving, at one or more collectors, monitored metrics data from one or more agents instrumented into monitored applications at process 302. The monitored metrics data are received in original high resolution (e.g., 1-minute resolution) by the collectors at the backend of the system, for example. The received monitored metrics data in original high resolution (e.g., 1-minute resolution) are at least temporarily stored in a distributed database, such as HBase at process 304. The stored metrics data in original high resolution are sent (e.g., by collectors) to aggregators organized into a consistent hash ring at process 306. The aggregators perform appropriate rollup of the metrics data in original high resolution into different resolutions at process 308. Examples of rolling up metrics data into different resolutions are disclosed with respect to FIGS. 4A and 4B.

All of the aggregators are registered with the coordinator, such as ZooKeeper to identify the aggregators that are available to form a consistent hash ring. As shown in FIG. 1B, the process 106 for sending the stored metrics data in original high resolution to aggregators organized into a consistent hash ring includes obtaining information on the aggregators that are available to form a hash ring at process 110. The hash ring is formed by applying a has function to the available aggregators at process 111. The collectors apply the same hash function that is used to create the consistent hash ring on the received time series of metric data at process 112 to return a hash code that will point to a location on the consistent hash ring. The aggregator closest to the hash code on the consistent hash ring will process the metric for all plurality of time. The collectors use this technique to route the incoming time series metric data to the correct aggregator node on the consistent hash ring at process 113. Thus, all time series data for a particular metric are sent to the same aggregator until an aggregator fails. However, each aggregator may process multiple metrics.

Thus, the collectors can be configured to apply the same hash function used to form the consistent hash ring on the received time series metric data for a given performance metric to generate a hash code that points to a location on the consistent hash ring, so that one of the aggregators closest to the hash code on the consistent hash ring is assigned to process all of the received time series metric data for the given performance metric. The collectors can be configured to use the hash code to route the received time series metric data for each performance metric to corresponding aggregator node on the consistent hash ring. The coordinator can include a quorum based coordinator service that provides information to the plurality of collectors about the information on all of the aggregators that are available to form the consistent hash ring. For example, when there are 10 collectors and 5 aggregators in the system, all 10 collectors will get the same list of aggregators from the quorum based coordinator. The collectors will form the same consistent hash ring by using the same hash function on the aggregators (host and port info). When the time series metric data for a given metric arrives at a collector, the collector applies the same hash function and routes the time series metric data to the aggregator identified based on the hash function. Because the hash function is same for all 10 collectors, when the time series metric data for the given metric arrives at different collectors for each minute in a 10 minute window, all of the time series metric data for the given metric will be routed to a single aggregator as long as the aggregator is available for processing.

The collectors can be totally stateless allowing for arbitrarily adding or removing of collectors to the metric processing system to collect metrics from agents, depending on the load on the system. Thus, the metric processing system is scalable. Arranging the aggregators in a consistent hash ring can allow the collectors to route every metrics to the appropriate aggregator for all reported times. This arrangement can allow aggregators to roll up or aggregate metrics in various configured rollup intervals.

FIGS. 4A and 4B are block diagrams illustrating examples 400 and 410 of rolling up collected metrics data into different resolutions. Time rollups are performed by rolling up and aggregating raw granular (e.g., 1-minute interval) time series data into progressively less granular data. As shown in FIG. 4A, the raw collected data 402 in high resolution (e.g., t-minute resolution) are rolled up to obtain Rollup 1 data 404 by averaging the collected data 402 every X ‘t-time’ interval. Thus, the Rollup 1 data has a resolution that is reduced by 1/X compared to the collected data 402. The Rollup 1 data are rolled up to obtain Rollup 2 data 406 by averaging the Rollup 1 data every Y ‘Rollup 1’ interval. Thus, the Rollup 1 data has a resolution that is reduced by 1/Y compared to the Rollup 1 data 404 and 1/XY comparted to the collected data 402. The Rollup N data 408 are obtained by rolling up Rollup N−1 data by averaging the Rollup N−1 data every Z ‘Rollup N−1’ interval. Thus, the Rollup N data has a resolution that is reduced by 1/Z compared to the Rollup N−1 data (not shown) or by 1/XZ compared to the collected data 402. In this manner, each Rollup data of a given resolution is rolled up to the next lower resolution.

FIG. 4B shows an example 410 of the rollup process illustrated in FIG. 2A. As shown in FIG. 4A, the raw 1-minute resolution time series Raw data 412 can be rolled up into 10-minute resolution data buckets (e.g., by averaging the 1-minute interval data every 10 minutes) 414. The rolled up 10-minute resolution buckets can be rolled up into hourly resolution data buckets (e.g., by averaging every six 10-minute buckets into each hourly bucket) 416. The rolled up hourly buckets can be rolled up into daily resolution buckets (e.g., by averaging every twenty-four 1-hour buckets into each daily bucket (not shown). The rolled up daily buckets can be rolled up into weekly resolution data buckets (e.g., by averaging every seven daily buckets into each weekly bucket) (not shown). The rolled up weekly buckets can be rolled into monthly resolution data buckets (e.g., by averaging every 4 weekly buckets into each monthly bucket) (not shown). The rolled up monthly buckets can be rolled into yearly resolution buckets (e.g., by rolling up every 12 monthly buckets into each yearly bucket) 418. In some implementations, other granularities in the metrics rollup can be used.

Distributed Time Rollup Design

The disclosed technology can provide for a metrics processing system that uses a micro services architecture that ingests metrics data in real time and time rolls up in the data stream. The results of the rollup are stored in a distributed database, such as HBase. Storing the results of rollups in HBase provides advantages. For example, HBase enables a sharding strategy to create ordered partitioning of its key ranges. Using the sharding strategy, long time range queries (e.g., over weeks, months, years, etc.) can be implemented and aggregates can be efficiently applied on the results of the long time range queries at a single shard level. All keys are lexicographically sorted and stored in shards called regions by range. The keys can be designed to store several years of metric data in a single shard or region in HBase.

Exemplary HBase Table Design

FIGS. 5A and 5B are diagrams showing exemplary table designs 500 and 510 for HBase. For example, the HBase table 500 can have multiple column families (e.g., 1, 2, . . . , and N)—one column for each data resolution. Each column family has a different TTL configuration matching a corresponding retention period for a different metric resolution. The example table 510 in FIG. 5B has 3 column families 1, 2, and 3. Each column family has a different TTL configuration—(Column Family 1: TTL 24 hours), (Column Family 2: TTL 8 days), and (Column Family 3: TTL 1 year)—matching the retention period for a different metric resolution. For example, in table 510, the 1-minute resolution data can be written into the first column family having retention period 1 day. After rolling up the metrics for 10 min and 60 minutes, the respective rollups can be stored in 2nd and 3rd column families. HBase can use the retention periods of the columns to automatically deletes metrics.

Exemplary HBase Metric Key Design

The metrics data received from the agents is time series data where every metric data point received has a time stamp associated with it. A metric key can be created to be time bucketed, and values can be stored against columns for each minutes. To avoid hot spotting, the metrics ID and the source before the time. In addition, a prefix salt based on the initial size of the HBase cluster can be used and the table can be pre-split at the time of setup. For example, when the metric key time bucket is set up to be 12 hours as shown in FIG. 5B, 720 (i.e., 60 minutes×12 hours) metric data point are received in 12 hours. These metric values can be stored as different column values depending on the resolution assigned for each column. For example, the column names can be set as the metric payload time. In FIG. 5B, the minute resolution level metric values are stored in the first column family. An exemplary metric key can be designed as shown in FIG. 5C to include: [prefix salt] [metric identity][12 hours time since epoch].

The 1-minute resolution metrics data from the first column family are rolled up to 10-minutes resolution metric data and stored in the 2nd column family every 10 minutes. Similarly, the 60-minutes rolled up metric data points are written to the 3rd column family every hour.

FIG. 6 is a block diagram illustrating a metrics data processing system 600 for rolling up metrics in real-time as disclosed in this patent document. The metrics data processing system 600 can be implemented in an application platform 601. Examples of the application platform are disclosed further with respect to FIGS. 10 and 11 below. The metrics processing system 600 is a backend system that receives metrics data in time series (m1 (t1−tn), m2 (t1−tn), m3 (t1−tn), . . . , mA (t1−tn)) from ‘A’ total agents 1, 2, 3, . . . , A (602, 604, 606, . . . , 608). The metrics processing system 600 can use Jetty based micro services to rollup the received metrics in real time. The Jetty based micro services in the metric processing system 400 can be organized into two groups—‘C’ total collectors C1 (610), C2 (612), . . . , C5 (614), . . . CC (416) and ‘B’ total aggregators a1 (618), a2 (620), a3 (622), and a4 (616). The numbers represented by n, N, A, C, and B can vary based on the deployment of the application intelligence platform 601. Also, n, N, A, C, and B may or may not be the same number.

In some implementations, the collector services 610, 612, 614, and 616 are placed behind an optional load balancer 609 that receives and distributes metric payload data coming from the instrumentation agents 602, 604, 606, and 608. The load balancer 609 can distribute the metric payload data from the agents 602, 604, 606, and 608 across the collectors 610, 612, 614, and 616 based on the load of each collector. When the load balancer 609 is not used at the backend, the agents 602, 604, 606, and 608 can include the load balancing process or alternatively, each agent can be assigned to one or more specific collectors. The collectors 610, 612, 614, and 616 process the incoming metric payload data and persists the received metric payload data into the HBase table in the 1st column family. The metric payload data persisting in the 1^(st) column family are 1-minute resolution metrics data. The collectors 610, 612, 614, and 416 send the 1-minute resolution metric data to the aggregator services a1 (618), a2 (620), a3 (622), and aB (624).

The aggregator services 618, 620, 622, and 624 perform time rollup of the 1-minute resolution metrics data and persist them to 2nd and 3rd column families respectively in the HBase table (e.g., HBase Tables 100, 500 and 510). The aggregator services 618, 620, 622, and 624 are organized into a consistent hash ring. Each of the aggregator services 618, 620, 622, and 624 can process a certain range in the consistent hash ring or metric range. Processing a certain range in the consistent hash ring or metric range ensures that any metric received at any collector at any time, will always be forwarded to the same aggregator service for performing the time rollup. For example, a single aggregator service receives all of the ten 1-minute metric data points for a metric, apply aggregate functions on the metric values, and save the aggregated value into HBase in the appropriate column family.

As shown in FIG. 6, each of the collectors 610, 612, 614, and 616 can receive metric data for multiple metrics. However, each of the collectors 610, 612, 614, and 616 may not receive all of the metric data points for a particular metric. This is due to the distribution of the metric payload through the load balancer 609, for example, to provide distributed processing of the large amount of data received from the agents 602, 604, 606, and 608. However, the collectors 610, 612, 614, and 616 can synchronize to forward metric data points for a given metric to the same aggregator 618, 620, 622, and 624.

In the examples system 600 shown in FIG. 46, the collectors [C1, C2 . . . , CC] are placed behind a load balancer 609 and aggregators [a1, a2, a3, . . . aB] are organized into a consistent hash ring. One instrumentation agent (Agent 1 (602)) is sending metric m1 every minute from time t1 till tn, another agent (Agent 2 (604)) is sending metric m2 every minute from time t1 till tn, a third agent (Agent 3 (606)) is sending metric m3 every minute from time t1 till tn, and so on until agent A (Agent A (608)) is sending metric mA every minute from time t1 till tn.

Payload p1 containing metrics m1, m2, and m3 sent at 10:00 am arrived at collector C5 (614). Payload p2 containing metrics m1, m2, and m3 sent at 10:01 am arrived at collector C1 (610). Payload p3 containing metrics m1, m2, and m3 sent at 10:02 am arrived at collector C2 (612). Thus, in this example, for each minute, the payload containing metrics m1, m2, and m3 landed at different collector nodes as shown above. Each collector applies a hash function based on the number of aggregators and routes the metric m1 to aggregator a1 (618), routes the metric m2 to aggregator a3 (622), and routes the metric m3 to aggregator aB (624). After 10 minutes, each of the aggregators a1 (618), a3 (622), and aB (624) can aggregate the 10 metric values for m1, m2, and m3 and write the aggregated values for m1, m2, and m3 to HBase. Similarly, after 60 minutes, aggregators a1 (618), a3 (622), and aB (624) can aggregate the 60 metric values for m1, m2, and m3 and write the aggregated values for m1, m2, and m3 to HBase.

Aggregators 618, 620, 622, and 624 are implemented used to aggregate the metric data for each metric rather than the collectors because collectors are stateless services that are placed behind a load balancer that distributes the load using a round robin rule. Each 1-minute payload for a metric sent from an instrumentation agent may end up being processed at different collectors based on the load balancing performed by the load balancer 609. Time rollups at the collector services for a metric cannot be performed because a single collector process may not have all 10 of the 1-minute level data points, for example. Routing the metric payloads from the collectors to the aggregators based on the hash code for every minute enables the metric processing system 600 to perform time roll up at the aggregator services 618, 620, 622, and 624.

Coordinating Collectors and Aggregators

The collectors 610, 612, 614, and 616 and aggregators 618, 620, 622, and 624 register with the coordinator 626, such as the ZooKeeper based quorum service at the start up. The coordinator 626 monitors the service availability for all of the micro services offered by the collectors 610, 612, 614, and 616 and aggregators 618, 620, 622, and 624. The collectors 610, 612, 614, and 616 retrieve the list of aggregators 618, 620, 622, and 624 at the start up from the coordinator 626. Each collector attaches a watcher to receive notification during an aggregator joining the quorum of the coordinator 626 or leaving the quorum. At any given point in time, all collector service nodes 610, 612, 614, and 616 will retrieve the same set of aggregator nodes 618, 620, 622, and 624 from coordinator 626. The collector nodes 610, 612, 614, and 616 can create a consistent hash ring using the retrieved aggregator nodes.

The coordination mechanism works well when the aggregator nodes 610, 612, 614, and 616 remain constant to allow all metric data points for a metric to be sent to the same aggregator. When the aggregator nodes 610, 612, 614, and 616 change by adding to or subtracting from the consistent hash ring of aggregators, the metric processing system 600 is scalable to dynamically add or subtract aggregators restfully without an interruption.

The makeup of the aggregator nodes can change for various reasons. For example, when the load increases, new aggregator nodes can be added to the ring. When the load decreases, one or more of the nodes can be removed from the ring.

In some implementations, during software upgrades, older aggregators can be removed from the ring and newer aggregators can be added to the ring continuously.

In some implementations, one or more aggregators might crash and new aggregators can be added to the ring to compensate for crashed nodes.

FIG. 7A is a process flow diagram of a process 700 for scaling the nodes of aggregators by adding a new aggregator to the ring. FIG. 7B is a block diagram illustrating the addition of the new aggregator described in process 700 of FIG. 7A.

In FIG. 7B, 4 aggregator nodes a1 (722), a2 (724), a3 (726), and a4 (728) form a consistent hash ring 720, but aggregator a2 (724) was added to the ring using the process 700 of FIG. 7A. Based on a condition, such as an increase in the load, a determination is made to add a new aggregator at process 702. A new aggregator node a2 (724) is added to the ring at process 704. In the example shown in FIG. 5B, the new aggregator node a2 (724) is added to the ring at 10:15 am. The added aggregator a2 (724) is indicated using a double ring in FIG. 5B. Adding the new aggregator a2 (724) requires redistributing the metric payload data to include the new aggregator a2 (724) at process 706. For example, as shown in FIG. 5B, any metric payload data for m1 arriving at a3 (726) will now go to aggregator a2 (724) after 10:15 am. If, for example, aggregator a3 (726) has received 15 data points for metric m1 before aggregator a2 (524) was added to the ring, aggregator a3 (726) can aggregate 15 minutes of data for the hour rollup and the remaining 45 minutes of metric data points will be rolled up by aggregator a2 (724). If both aggregators a2 (724) and a3 (726) are allowed to write the hour rolled up data into the 3rd column family in HBase with same column name “10:00”, one aggregator will over write other corrupting the hour rollup value for 10:00. This is because any change in the aggregator consistent hash ring will create corruption of the time rolled up data due to the splitting of metric payload data into multiple aggregators. The process 700 includes fixing or preventing data corruption at process 708.

FIG. 7C is a process flow diagram of the process 708 for fixing or preventing data corruption. The corrupted data fixing or prevention process 708 includes adding an aggregator suffix to the column name in HBase at process 710 before writing to the next rollup column family (e.g., for hourly roll up) at process 712. Using the aggregator suffix creates two cells (one from each aggregator) for the hour time rollup with different column names. For example, one cell in the column can be named “10:00_a3” to indicate m1 data written by aggregator a3 (726) with 15 metric data points aggregated. The other cell in the column can be named “10:00_a2” to indicate metric data written by aggregator a2 (724) with 45 data points aggregated. FIG. 7D shows an exemplary column 730 with the two cells. The values in the two cells are merged at process 714. For example, a read scan will pick up the values from both cells, and merge the values in real time before returning the results to the client. Using the read time resolution method two or more aggregated cells can be merged during scans.

FIG. 8A is a process flow diagram of a process 800 for scaling the nodes of aggregators by removing an aggregator to the ring. FIG. 8B is a block diagram illustrating the removal of the aggregator described in process 800 of FIG. 8A.

In FIG. 8B, 4 aggregator nodes a1 (822), a2 (824), a3 (826), and a4 (828) form a consistent hash ring 820, but aggregator a2 (824) is being removed from to the ring using the process 800 of FIG. 8A. Based on a condition, such as a decrease in the load, a determination is made to remove an aggregator at process 802. The desired aggregator is removed at process 804. Due to the removed aggregator, the metric payload data is redistributed at process 806. Metric values for the next minute after removal of aggregator a2 (824) will route to the next aggregator a3 (826) in the ring. The next aggregator a3 (826) will aggregate the remaining minutes of the hour and the aggregated values from both aggregators will be written to the HBase. Because the removal of the aggregator corrupts the rolled up data by creating two aggregated values, the process 800 includes fixing the corrupted data at process 808.

FIG. 8C is a process flow diagram of the process 808 for fixing or preventing data corruption due to the removed aggregator. After the node aggregator is removed from the consistent hash ring, the accumulated metric values from removed aggregator and the next aggregator that took over the accumulation are written into the database (e.g., HBase) at process 812 before terminating the process for the removed aggregator at process 814. To prevent or fix data corruption for the two sets of accumulated data, the column names in the database will have the aggregator name as a suffix at process 810 before writing the accumulated metric values to the database at process 812. The aggregator name suffix usage is similar to the approach for adding a new aggregator node to the ring as disclosed with respect to FIG. 7C above.

Using the aggregator suffix creates two cells (one from each aggregator) for the hour time rollup with different column names. FIG. 8D shows an exemplary column 830 with the two cells. The values in the two cells are merged at process 816. For example, a read scan will pick up the values from both cells, and merge the values in real time before returning the results to the client. Using the read time resolution method two or more aggregated cells can be merged during scans.

The disclosed technology also provides for means to repair time rolled up data corruption when an aggregator node crashes. In the event of an aggregator node crash, the crashed aggregator node would not be able to write the accumulated metric values into the database (e.g., HBase). FIG. 9A is a process flow diagram of a process for repairing data after a crash 900. FIG. 9B is a block diagram of an exemplary consistent hash ring of accumulators 920 that illustrates an aggregator crash. For example, in the consistent hash ring 920 of FIG. 9B, when aggregator a2 crashes at time 10:25 am, all the metric values for m1 being sent to a2 will be redistributed to aggregator a3 from the next minute (10:26 am). After the crash, aggregator a3 will receive and accumulate metric values from 10:26 am to 10:59 am-total of 35 data points. Aggregator a3 will write the metric data points into HBase for 35 data points. The initial 25 minutes of data for m1 received by accumulator a2 will be lost with the crashed aggregator a2.

FIG. 9C is a process flow diagram of the process 904 for performing the repair job. FIG. 9D is a process flow diagram of a process 912 for preparing for the repair job so that the repair job when performed is optimized. FIG. 9E is a block diagram illustrating buckets 930 created during the repair job preparation process. FIG. 9F is a process flow diagram showing an exemplary process 940 for performing a repair job after a crash once the preparation for the repair job has been integrated into the process.

For the process 900 shown in FIG. 9A, because the aggregators and collectors register themselves with the coordinator quorum service 626 and monitors the availability using watchers, the coordinator 626 can detect a node crash at process 902 and then perform a repair job at process 904. As shown in FIG. 9C, the repair job 904 includes replaying the not yet rolled up payload that arrived at the crashed accumulator a2 before the crash (e.g., from 10:00 am to 10:25 am) at process 906. The data received at the crashed accumulator a2 from 9:50 am to 9:59 should have been rolled up already. The 25 minutes of metric data for those metrics that have been lost with aggregator a2 crash obtained from the replay is sent to aggregator a3 at process 908 to be aggregated. The portion of 25 minutes received from the crashed aggregator is saved into HBase at process 910.

The repair job could be very expensive depending on the time of the crash. For example, when an aggregator crashes at 10:59 am, the repair job has to replay the entire 1-hour of payloads received. The disclosed technology provides for a technique 912 for preparing for the repair job by optimizing the replay process during the repair job as shown in FIG. 9D. To prepare for the repair job at process 912, the time range (e.g., 1-hour time range) is partitioned into multiple buckets (e.g., 6 buckets of 10 minutes each) that breaks up the time range into smaller manageable chunks at each aggregator at process 914. For the above example where aggregator a2 crashed, the first bucket can store metric data from 10:00 am to 10:09 am; the second bucket can store metric data from 10:10 am to 10:19 am; the third bucket can store metric data from 10:20 am to 10:29; the fourth bucket can store metric data from 10:30 am to 10:39 am; the fifth metric data can store metric data from 10:40 am to 10:49 am; and the 6th bucket can store the metric data from 10:50 am to 10:59 am. To have buffer beyond the one-hour time range and into the next hour, additional buckets (e.g., another 3 buckets for 30 minutes of next hour) are added to the list at process 916. The values in each bucket are accumulated at each accumulator and written to the database, such as HBase. Specifically, the metric data values in the 1^(st) bucket are accumulated at process 918. An aggregator suffix is used identify the accumulator value at process 920 before writing to the database at process 922. When determined that more buckets are available at process 924, the metric data values in the next bucket are accumulated at process 926 and merged with the accumulated values from the previous bucket at process 928. The same aggregator suffix is used to write the merged value to the database, such as HBase at processes 920 and 922. The merged value overrides the previously stored value in HBase. The values in each of the subsequent buckets are accumulated and merged with previous bucket until all of the buckets are processed.

FIG. 9E shows an exemplary repair process using buckets 930 created during the preparation process. For example, from 10:00 am to 10:09 am, the aggregator accumulates all 10 metric data points in the 1st bucket b1. At 10:10 am, the aggregator writes to HBase the first 10 data point aggregated value from the 1^(st) bucket b1 with an aggregator suffix added to the column name. From 10:10 am to 10:19 am, the aggregator can accumulate all 10 metric data points in the 2nd bucket b2. At 10:20 am, the aggregator can merge the metric values from the 1^(st) and second buckets b1 and b2 and write to HBase overwriting the first value written after 10 minutes. After every 10-minute window, the metric values accumulated in the current bucket are merged with all the previous buckets and then written to HBase overwriting the previous value. The same aggregator suffix, e.g. 10:00_a2, is used as the column name. The accumulating, merging and writing the metric values from each bucket continues until all buckets for the entire time range (e.g., 1 hour in this crash example) have been processed.

The added buckets b7, b8, and b9 are used to store the next Hours accumulated metric values. After 11:30 am (the end of the added buckets in this example), new metric values can be written to bucket 1, and so on to repeat the process. After processing the 9 buckets, 1 hour 30 minutes of aggregated data are stored in the aggregator memory.

FIG. 9F is a process flow diagram of a process 940 for repairing data after an aggregator crashes and once the preparation process 912 has been performed to partition the time range. Due to the preparation process, when aggregator a2 crashes (902) at 10:25 am, the only bucket that could be corrupted would be the 3rd bucket b3. The crashed aggregator a2 would have already written the rolled up data till 10:20 am in column “10:00_a2” using the aggregator suffix. After aggregator a2 crashes, from 10:25 am forward, all metric data values are sent to aggregator a3 till 10:59 am, the next roll up time. At aggregator a3, buckets 4, 5 and 6 would have correct aggregated metric values. The third bucket b3 will have only 5 data points and that will be incorrect.

Thanks to the preparation process 912 of partitioning the time range, the repair job 904 can be performed for only a 10-minute time range 10:20 am to 10:29 am. Thus, the data is replayed for only the 10 minutes in the event of an aggregator node crash. The accumulated buckets in aggregator a3 can be written to HBase with column name having suffix a3, e.g. “10:00_a2”. In some implementations, the number of data points in each bucket can vary depending on the time range to be partitioned and the number of buckets created. The read scans can merge both cells (from both aggregators) in real time and send the results to the client program. The read time resolution method is same as described above for FIGS. 7C and 8C.

Application Intelligence Platform Architecture

The disclosed technology for metric payload ingestion and replay and distributed metric data time rollup in real-time can be implemented in a metric processing system in communication with the controller or controllers of an application intelligence platform. As shown in FIG. 6, the metric processing system can include collectors and aggregators behind a load balance. FIG. 10 is a block diagram of an exemplary application intelligence platform 1000 that can implement the metric payload ingestion and replay and distributed metric data time rollup in real-time as disclosed in this patent document. The application intelligence platform is a system that monitors and collect metrics of performance data for an application environment being monitored. At the simplest structure, the application intelligence platform includes one or more agents 1010, 1012, 1014, 1016 and one or more controllers 1020. While FIG. 10 shows four agents communicatively linked to a single controller, the total number of agents and controller can vary based on a number of factors including the number of applications monitored, how distributed the application environment is, the level of monitoring desired, the level of user experience desired, etc.

Controllers, Agents, and Metric Processing System

The controller 1020 is the central processing and administration server for the application intelligence platform. The controller 1020 serves a browser-based user interface (UI) 830 that is the primary interface for monitoring, analyzing, and troubleshooting the monitored environment. The controller 1020 can control and manage monitoring of business transactions distributed over application servers. Specifically, the controller 1020 can receive runtime data from agents 1010, 1012, 1014, 1016 and coordinators, associate portions of business transaction data, communicate with agents to configure collection of runtime data, and provide performance data and reporting through the interface 1030. The interface 1030 may be viewed as a web-based interface viewable by a client device 1040. In some implementations, a client device 1040 can directly communicate with controller 1020 to view an interface for monitoring data. The controller can communicate with the multiple agents return the appropriate pre-fetch application performance data responsive to the request for the pre-fetch application performance data. In some implementations, an application may touch more than one machine and thus application performance data from multiple agents can be combined together by the controller.

In the Software as as Service (SaaS) implementation, a controller instance 1020 is hosted remotely by a provider of the application intelligence platform 1000. In the on-premise (On-Prem) implementation, a controller instance 1020 is installed locally and self-administered.

The controllers 1020 receive data from different agents 1010, 1012, 1014, 1016 deployed to monitor applications, databases and database servers, servers, and end user clients for the monitored environment. Any of the agents 1010, 1012, 1014, 1016 can be implemented as different types of agents specific monitoring duties. For example, application agents are installed on each server that hosts applications to be monitored. Instrumenting an agent adds an application agent into the runtime process of the application.

Database agents are software (e.g., Java program) installed on a machine that has network access to the monitored databases and the controller. Database agents queries the databases monitored to collect metrics and passes the metrics for display in the metric browser—database monitoring and in the databases pages of the controller UI. Multiple database agents can report to the same controller. Additional database agents can be implemented as backup database agents to take over for the primary database agents during a failure or planned machine downtime. The additional database agents can run on the same machine as the primary agents or on different machines. A database agent can be deployed in each distinct network of the monitored environment. Multiple database agents can run under different user accounts on the same machine.

Standalone machine agents are standalone programs (e.g., standalone Java program) that collect hardware-related performance statistics from the servers in the monitored environment. The standalone machine agents can be deployed on machines that host application servers, database servers, messaging servers, Web servers, etc. A standalone machine agent has an extensible architecture.

End user monitoring (EUM) is performed using browser agents and mobile agents to provide performance information from the point of view of the client, such as a web browser or a mobile native application. Browser agents and mobile agents are unlike other monitoring through application agents, database agents, and standalone machine agents that being on the server. Through EUM, web use (e.g., by real users or synthetic agents), mobile use, or any combination can be monitored depending on the monitoring needs.

Browser agents are small files using web-based technologies, such as JavaScript agents injected into each instrumented web page, as close to the top as possible, as the web page is served and collects data. Once the web page has completed loading, the collected data is bundled into a beacon and sent to the EUM cloud for processing and ready for retrieval by the controller. Browser real user monitoring (Browser RUM) provides insights into the performance of a web application from the point of view of a real or synthetic end user. For example, Browser RUM can determine how specific Ajax or iframe calls are slowing down page load time and how server performance impact end user experience in aggregate or in individual cases.

A mobile agent is a small piece of highly performant code that gets added to the source of the mobile application. Mobile RUM provides information on the native iOS or Android mobile application as the end users actually use the mobile application. Mobile RUM provides visibility into the functioning of the mobile application itself and the mobile application's interaction with the network used and any server-side applications the mobile application communicates with.

The application intelligence platform 1000 can include a metric processing system 1050 that includes controllers 1052 and aggregators 1054. The metric processing system 1050 can be implemented substantially similar to the metric processing system 600 shown in FIG. 6. As disclosed with respect to FIG. 6, the metric processing system 600 and 1050 can perform the distributed metric data time rollup in real-time as disclosed in this patent document. The metric processing system 1050 can communicate with controller 1020 to provide the time rolled up data to the controller when requested. In some implementations, the metric payload data from the agents are received through the controller 1020.

Application Intelligence Monitoring

The disclosed technology can provide application intelligence data by monitoring an application environment that includes various services such as web applications served from an application server (e.g., Java virtual machine (JVM), Internet Information Services (IIS), Hypertext Preprocessor (PHP) Web server, etc.), databases or other data stores, and remote services such as message queues and caches. The services in the application environment can interact in various ways to provide a set of cohesive user interactions with the application, such as a set of user services applicable to end user customers.

Application Intelligence Modeling

Entities in the application environment (such as the JBoss service, MQSeries modules, and databases) and the services provided by the entities (such as a login transaction, service or product search, or purchase transaction) are mapped to an application intelligence model. In the application intelligence model, a business transaction represents a particular service provided by the monitored environment. For example, in an e-commerce application, particular real-world services can include user logging in, searching for items, or adding items to the cart. In a content portal, particular real-world services can include user requests for content such as sports, business, or entertainment news. In a stock trading application, particular real-world services can include operations such as receiving a stock quote, buying, or selling stocks.

Business Transactions

A business transaction representation of the particular service provided by the monitored environment provides a view on performance data the context of the various tiers that participate in processing a particular request. A business transaction represents the end-to-end processing path used to fulfill a service request in the monitored environment. Thus, a business environment is a type of user-initiated action in the monitored environment defined by an entry point and a processing path across application servers, databases, and potentially many other infrastructure components. Each instance of a business transaction is an execution of that transaction in response to a particular user request. A business transaction can be created by detecting incoming requests at an entry point and tracking the activity associated with request at the originating tier and across distributed components in the application environment. A flow map can be generated for a business transaction that shows the touch points for the business transaction in the application environment.

Performance monitoring can be oriented by business transaction to focus on the performance of the services in the application environment from the perspective of end users. Performance monitoring based on business transaction can provide information on whether a service is available (e.g., users can log in, check out, or view their data), response times for users, and the cause of problems when the problems occur.

Business Applications

A business application is the top-level container in the application intelligence model. A business application contains a set of related services and business transactions. In some implementations, a single business application may be needed to model the environment. In some implementations, the application intelligence model of the application environment can be divided into several business applications. Business applications can be organized differently based on the specifics of the application environment. One consideration is to organize the business applications in a way that reflects work teams in a particular organization, since role-based access controls in the Controller UI are oriented by business application.

Nodes

A node in the application intelligence model corresponds to a monitored server or JVM in the application environment. A node is the smallest unit of the modeled environment. In general, a node corresponds to an individual application server, JVM, or CLR on which a monitoring Agent is installed. Each node identifies itself in the application intelligence model. The Agent installed at the node is configured to specify the name of the node, tier, and business application under which the Agent reports data to the Controller.

Tiers

Business applications contain tiers, the unit in the application intelligence model that includes one or more nodes, Each node represents an instrumented service (such as a web application). While a node can be a distinct application in the application environment, in the application intelligence model, a node is a member of a tier, which, along with possibly many other tiers, make up the overall logical business application.

Tiers can be organized in the application intelligence model depending on a mental model of the monitored application environment. For example, identical nodes can be grouped into a single tier (such as a cluster of redundant servers). In some implementations, any set of nodes, identical or not, can be grouped for the purpose of treating certain performance metrics as a unit into a single tier.

The traffic in a business application flows between tiers and can be visualized in a flow map using lines between tiers. In addition, the lines indicating the traffic flows between tiers can be annotated with performance metrics. In the application intelligence model, there may not be any interaction among nodes within a single tier. Also, in some implementations, an application agent node cannot belong to more than one tier. Similarly, a machine agent cannot belong to more than one tier. However, more than one machine agent can be installed on a machine.

Backend System

A backend is a component that participates in the processing of a business transaction instance. A backend is not instrumented by an agent. A backend may be a web server, database, message queue, or other type of service. The agent recognizes calls to these backend services from instrumented code (called exit calls). When a service is not instrumented and cannot continue the transaction context of the call, the agent determines that the service is a backend component. The agent picks up the transaction context at the response at the backend and continues to follow the context of the transaction from there.

Performance information is available for the backend call. For detailed transaction analysis for the leg of a transaction processed by the backend, the database, web service, or other application need to be instrumented.

Baselines and Thresholds

The application intelligence platform uses both self-learned baselines and configurable thresholds to help identify application issues. A complex distributed application has a large number of performance metrics and each metric is important in one or more contexts. In such environments, it is difficult to determine the values or ranges that are normal for a particular metric; set meaningful thresholds on which to base and receive relevant alerts; and determine what is a “normal” metric when the application or infrastructure undergoes change. For these reasons, the disclosed application intelligence platform can perform anomaly detection based on dynamic baselines or thresholds.

The disclosed application intelligence platform automatically calculates dynamic baselines for the monitored metrics, defining what is “normal” for each metric based on actual usage. The application intelligence platform uses these baselines to identify subsequent metrics whose values fall out of this normal range. Static thresholds that are tedious to set up and, in rapidly changing application environments, error-prone, are no longer needed.

The disclosed application intelligence platform can use configurable thresholds to maintain service level agreements (SLAs) and ensure optimum performance levels for your system by detecting slow, very slow, and stalled transactions. Configurable thresholds provide a flexible way to associate the right business context with a slow request to isolate the root cause.

Health Rules, Policies, and Actions

In addition, health rules can be set up with conditions that use the dynamically generated baselines to trigger alerts or initiate other types of remedial actions when performance problems are occurring or may be about to occur.

For example, dynamic baselines can be used to automatically establish what is considered normal behavior for a particular application. Policies and health rules can be used against baselines or other health indicators for a particular application to detect and troubleshoot problems before users are affected. Health rules can be used to define metric conditions to monitor, such as when the “average response time is four times slower than the baseline”. The health rules can be created and modified based on the monitored application environment.

Examples of health rules for testing business transaction performance can include business transaction response time and business transaction error rate. For example, health rule that tests whether the business transaction response time is much higher than normal can define a critical condition as the combination of an average response time greater than the default baseline by 3 standard deviations and a load greater than 50 calls per minute. This health rule can define a warning condition as the combination of an average response time greater than the default baseline by 2 standard deviations and a load greater than 100 calls per minute. The health rule that tests whether the business transaction error rate is much higher than normal can define a critical condition as the combination of an error rate greater than the default baseline by 3 standard deviations and an error rate greater than 10 errors per minute and a load greater than 50 calls per minute. This health rule can define a warning condition as the combination of an error rate greater than the default baseline by 2 standard deviations and an error rate greater than 5 errors per minute and a load greater than 50 calls per minute.

Policies can be configured to trigger actions when a health rule is violated or when any event occurs. Triggered actions can include notifications, diagnostic actions, auto-scaling capacity, running remediation scripts.

Metrics

Most of the metrics relate to the overall performance of the application or business transaction (e.g., load, average response time, error rate, etc.) or of the application server infrastructure (e.g., percentage CPU busy, percentage of memory used, etc.). The Metric Browser in the controller UI can be used to view all of the metrics that the agents report to the controller.

In addition, special metrics called information points can be created to report on how a given business (as opposed to a given application) is performing. For example, the performance of the total revenue for a certain product or set of products can be monitored. Also, information points can be used to report on how a given code is performing, for example how many times a specific method is called and how long it is taking to execute. Moreover, extensions that use the machine agent can be created to report user defined custom metrics. These custom metrics are base-lined and reported in the controller, just like the built-in metrics.

All metrics can be accessed programmatically using a Representational State Transfer (REST) API that returns either the JavaScript Object Notation (JSON) or the eXtensible Markup Language (XML) format. Also, the REST API can be used to query and manipulate the application environment.

Snapshots

Snapshots provide a detailed picture of a given application at a certain point in time. Snapshots usually include call graphs that allow that enables drilling down to the line of code that may be causing performance problems. The most common snapshots are transaction snapshots.

Exemplary Implementation of Application Intelligence Platform

FIG. 11 is a block diagram of an exemplary system 1100 for metric payload ingestion and replay and distributed metric data time rollup in real-time as disclosed in this patent document, including the techniques disclosed with respect to FIGS. 1A through 9F. The system 1100 in FIG. 11 includes client device 1105 and 1192, mobile device 1115, network 1120, network server 1125, application servers 1130, 1140, 1150 and 1160, agents 1112, 1119, 1134, 1144, 1154 and 1164, asynchronous network machine 1170, data stores 1180 and 1185, controller 1190, and data collection server 1195.

The system 1100 can include a metric processing system 1192 that includes controllers and aggregators. The metric processing system 1192 can be implemented substantially similar to the metric processing system 600 shown in FIG. 6. As disclosed with respect to FIG. 4, the metric processing system 600, 1050, and 1192 can perform the distributed metric data time rollup in real-time as disclosed in this patent document. The metric processing system 992 can communicate with controller 1190 to provide the time rolled up data to the controller when requested. In some implementations, the metric payload data from the agents are received through the controller 1190.

Client device 1105 may include network browser 1110 and be implemented as a computing device, such as for example a laptop, desktop, workstation, or some other computing device. Network browser 1110 may be a client application for viewing content provided by an application server, such as application server 1130 via network server 1125 over network 1120.

Network browser 1110 may include agent 1112. Agent 1112 may be installed on network browser 1110 and/or client 1105 as a network browser add-on, downloading the application to the server, or in some other manner. Agent 1112 may be executed to monitor network browser 1110, the operating system of client 1105, and any other application, API, or other component of client 1105. Agent 1112 may determine network browser navigation timing metrics, access browser cookies, monitor code, and transmit data to data collection 1160, controller 1190, or another device. Agent 1112 may perform other operations related to monitoring a request or a network at client 1105 as discussed herein.

Mobile device 1115 is connected to network 1120 and may be implemented as a portable device suitable for sending and receiving content over a network, such as for example a mobile phone, smart phone, tablet computer, or other portable device. Both client device 1105 and mobile device 1115 may include hardware and/or software configured to access a web service provided by network server 1125.

Mobile device 1115 may include network browser 1117 and an agent 1119. Mobile device may also include client applications and other code that may be monitored by agent 1119. Agent 1119 may reside in and/or communicate with network browser 1117, as well as communicate with other applications, an operating system, APIs and other hardware and software on mobile device 1115. Agent 1119 may have similar functionality as that described herein for agent 1112 on client 1105, and may repot data to data collection server 1160 and/or controller 1190.

Network 1120 may facilitate communication of data between different servers, devices and machines of system 1100 (some connections shown with lines to network 1120, some not shown). The network may be implemented as a private network, public network, intranet, the Internet, a cellular network, Wi-Fi network, VoIP network, or a combination of one or more of these networks. The network 1120 may include one or more machines such as load balance machines and other machines.

Network server 1125 is connected to network 1120 and may receive and process requests received over network 1120. Network server 1125 may be implemented as one or more servers implementing a network service, and may be implemented on the same machine as application server 1130 or one or more separate machines. When network 1120 is the Internet, network server 1125 may be implemented as a web server.

Application server 1130 communicates with network server 1125, application servers 1140 and 1150, and controller 1190. Application server 1130 may also communicate with other machines and devices (not illustrated in FIG. 11). Application server 1130 may host an application or portions of a distributed application. The host application 1132 may be in one of many platforms, such as including a Java, PHP, .Net, and Node.JS, be implemented as a Java virtual machine, or include some other host type. Application server 1130 may also include one or more agents 1134 (i.e. “modules”), including a language agent, machine agent, and network agent, and other software modules. Application server 1130 may be implemented as one server or multiple servers as illustrated in FIG. 11.

Application 1132 and other software on application server 1130 may be instrumented using byte code insertion, or byte code instrumentation (BCI), to modify the object code of the application or other software. The instrumented object code may include code used to detect calls received by application 1132, calls sent by application 1132, and communicate with agent 1134 during execution of the application. BCI may also be used to monitor one or more sockets of the application and/or application server in order to monitor the socket and capture packets coming over the socket.

In some embodiments, server 1130 may include applications and/or code other than a virtual machine. For example, servers 1130, 1140, 1150, and 1160 may each include Java code, .Net code, PHP code, Ruby code, C code, C++ or other binary code to implement applications and process requests received from a remote source. References to a virtual machine with respect to an application server are intended to be for exemplary purposes only.

Agents 1134 on application server 1130 may be installed, downloaded, embedded, or otherwise provided on application server 1130. For example, agents 1134 may be provided in server 1130 by instrumentation of object code, downloading the agents to the server, or in some other manner. Agent 1134 may be executed to monitor application server 1130, monitor code running in a virtual machine 1132 (or other program language, such as a PHP, .Net, or C program), machine resources, network layer data, and communicate with byte instrumented code on application server 1130 and one or more applications on application server 1130.

Each of agents 1134, 1144, 1154 and 1164 may include one or more agents, such as language agents, machine agents, and network agents. A language agent may be a type of agent that is suitable to run on a particular host. Examples of language agents include a JAVA agent, .Net agent, PHP agent, and other agents. The machine agent may collect data from a particular machine on which it is installed. A network agent may capture network information, such as data collected from a socket.

Agent 1134 may detect operations such as receiving calls and sending requests by application server 1130, resource usage, and incoming packets. Agent 1134 may receive data, process the data, for example by aggregating data into metrics, and transmit the data and/or metrics to controller 1190. Agent 1134 may perform other operations related to monitoring applications and application server 1130 as discussed herein. For example, agent 1134 may identify other applications, share business transaction data, aggregate detected runtime data, and other operations.

An agent may operate to monitor a node, tier or nodes or other entity. A node may be a software program or a hardware component (e.g., memory, processor, and so on). A tier of nodes may include a plurality of nodes which may process a similar business transaction, may be located on the same server, may be associated with each other in some other way, or may not be associated with each other.

A language agent may be an agent suitable to instrument or modify, collect data from, and reside on a host. The host may be a Java, PHP, .Net, Node.JS, or other type of platform. Language agent may collect flow data as well as data associated with the execution of a particular application. The language agent may instrument the lowest level of the application to gather the flow data. The flow data may indicate which tier is communicating with which tier and on which port. In some instances, the flow data collected from the language agent includes a source IP, a source port, a destination IP, and a destination port. The language agent may report the application data and call chain data to a controller. The language agent may report the collected flow data associated with a particular application to a network agent.

A network agent may be a standalone agent that resides on the host and collects network flow group data. The network flow group data may include a source IP, destination port, destination IP, and protocol information for network flow received by an application on which network agent is installed. The network agent may collect data by intercepting and performing packet capture on packets coming in from a one or more sockets. The network agent may receive flow data from a language agent that is associated with applications to be monitored. For flows in the flow group data that match flow data provided by the language agent, the network agent rolls up the flow data to determine metrics such as TCP throughput, TCP loss, latency and bandwidth. The network agent may then report the metrics, flow group data, and call chain data to a controller. The network agent may also make system calls at an application server to determine system information, such as for example a host status check, a network status check, socket status, and other information.

A machine agent may reside on the host and collect information regarding the machine which implements the host. A machine agent may collect and generate metrics from information such as processor usage, memory usage, and other hardware information.

Each of the language agent, network agent, and machine agent may report data to the controller. Controller 1190 may be implemented as a remote server that communicates with agents located on one or more servers or machines. The controller may receive metrics, call chain data and other data, correlate the received data as part of a distributed transaction, and report the correlated data in the context of a distributed application implemented by one or more monitored applications and occurring over one or more monitored networks. The controller may provide reports, one or more user interfaces, and other information for a user.

Agent 1134 may create a request identifier for a request received by server 1130 (for example, a request received by a client 1105 or 1115 associated with a user or another source). The request identifier may be sent to client 1105 or mobile device 1115, whichever device sent the request. In embodiments, the request identifier may be created when a data is collected and analyzed for a particular business transaction.

Each of application servers 1140, 1150 and 1160 may include an application and agents. Each application may run on the corresponding application server. Each of applications 1142, 1152 and 1162 on application servers 1140-1160 may operate similarly to application 1132 and perform at least a portion of a distributed business transaction. Agents 1144, 1154 and 1164 may monitor applications 1142-1162, collect and process data at runtime, and communicate with controller 1190. The applications 1132, 1142, 1152 and 1162 may communicate with each other as part of performing a distributed transaction. In particular, each application may call any application or method of another virtual machine.

Asynchronous network machine 1170 may engage in asynchronous communications with one or more application servers, such as application server 1150 and 1160. For example, application server 150 may transmit several calls or messages to an asynchronous network machine. Rather than communicate back to application server 1150, the asynchronous network machine may process the messages and eventually provide a response, such as a processed message, to application server 1160. Because there is no return message from the asynchronous network machine to application server 1150, the communications between them are asynchronous.

Data stores 1180 and 1185 may each be accessed by application servers such as application server 1150. Data store 1185 may also be accessed by application server 1150. Each of data stores 1180 and 1185 may store data, process data, and return queries received from an application server. Each of data stores 1180 and 1185 may or may not include an agent.

Controller 1190 may control and manage monitoring of business transactions distributed over application servers 1130-1160. In some embodiments, controller 1190 may receive application data, including data associated with monitoring client requests at client 1105 and mobile device 1115, from data collection server 1160. In some embodiments, controller 1190 may receive application monitoring data and network data from each of agents 1112, 1119, 1134, 1144 and 1154. Controller 1190 may associate portions of business transaction data, communicate with agents to configure collection of data, and provide performance data and reporting through an interface. The interface may be viewed as a web-based interface viewable by client device 1192, which may be a mobile device, client device, or any other platform for viewing an interface provided by controller 1190. In some embodiments, a client device 1192 may directly communicate with controller 1190 to view an interface for monitoring data.

Client device 1192 may include any computing device, including a mobile device or a client computer such as a desktop, work station or other computing device. Client computer 1192 may communicate with controller 1190 to create and view a custom interface. In some embodiments, controller 1190 provides an interface for creating and viewing the custom interface as a content page, e.g., a web page, which may be provided to and rendered through a network browser application on client device 1192.

Applications 1132, 1142, 1152 and 1162 may be any of several types of applications. Examples of applications that may implement applications 1132-1162 include a Java, PHP, .Net, Node.JS, and other applications.

FIG. 12 is a block diagram of a computer system 1200 for implementing the present technology. System 1200 of FIG. 12 may be implemented in the contexts of the likes of clients 1105, 1192, mobile device 1115, network server 1125, servers 1130, 1140, 1150, 1160, a synchronous network machine 1170 and controller 1190.

The computing system 1200 of FIG. 12 includes one or more processors 1210 and memory 1220. Main memory 1220 stores, in part, instructions and data for execution by processor 1210. Main memory 1210 can store the executable code when in operation. The system 1200 of FIG. 12 further includes a mass storage device 1230, portable storage medium drive(s) 1240, output devices 1250, user input devices 1260, a graphics display 1270, and peripheral devices 1280.

Examples of implementations for distributed metric data time rollup in real-time is disclosed. Specifically, the disclosed technology can enable distributed consistent hash backed metric time rollup mechanism in real time using read time resolution technique, with built in support for partial service failures, with high availability.

In one aspect, a system for distributed consistent hash backed time rollup of performance metric data is disclosed. The system includes a plurality of collectors configured to receive, time series metrics data for a plurality of performance metrics from one or more agents instrumented into monitored applications; a plurality of aggregators communicatively connected to the collectors and configured to aggregate the received time series metric data for the plurality of performance metrics, wherein each aggregator is assigned to aggregate all received time series metrics data for one or more of the plurality of performance metrics; and a quorum based coordinator communicatively connected to the plurality of collectors and plurality of aggregators and configured to provide collectors with information on the plurality of aggregators including assignments of the performance metrics to each aggregator.

The system can be implemented in various ways to include one or more of the following features. For example, the aggregators can be arranged in a consistent hash ring using a hash function. The coordinator can detect whether one of the plurality of aggregators has been removed from the hash ring or whether a new aggregator has been added to the hash ring. Each aggregator can perform time roll up of the received time series metric data for the assigned one or more performance metric. Each aggregator can receive the time series metrics data for the assigned one or more of the plurality of performance metrics from two or more of the plurality of collectors. The coordinator can detect whether one of the plurality of aggregators has been removed from the hash ring. The collectors can be configured to apply the same hash function used to form the hash ring on the received time series metric data for a given performance metric to generate a hash code that points to a location on the hash ring, so that one of the aggregators closest to the hash code on the hash ring is assigned to process all of the received time series metric data for the given performance metric. The collectors can be configured to use the hash code to route the received time series metric data for each performance metric to corresponding aggregator node on the consistent hash ring. The coordinator can include a quorum based coordinator service that provides information to the plurality of collectors about the information on all of the aggregators that are available to form the consistent hash ring. For example, when there are 10 collectors and 5 aggregators in the system, all 10 collectors will get the same list of aggregators from the quorum based coordinator. The collectors will form the same consistent hash ring by using the same hash function on the aggregators (host and port info). When the time series metric data for a given metric arrives at a collector, the collector applies the same hash function and routes the time series metric data to the aggregator identified based on the hash function. Because the hash function is same for all 10 collectors, when the time series metric data for the given metric arrives at different collectors for each minute in a 10 minute window, all of the time series metric data for the given metric will be routed to a single aggregator as long as the aggregator is available for processing.

The collectors can be totally stateless allowing for arbitrarily adding or removing of collectors to the metric processing system to collect metrics from agents, depending on the load on the system. Thus, the metric processing system is scalable. Arranging the aggregators in a consistent hash ring can allow the collectors to route every metrics to the appropriate aggregator for all reported times. This arrangement can allow aggregators to roll up or aggregate metrics in various configured rollup intervals.

In another aspect, a method for distributed consistent hash backed time rollup of performance metric data is disclosed. The method includes receiving, at a plurality of collectors, time series metrics data for a plurality of performance metrics from one or more agents instrumented into monitored applications; aggregating, at a plurality of aggregators communicatively connected to the collectors to form a hash ring, the received time series metrics data for the plurality of performance metrics, wherein each aggregator is assigned to aggregate all received time series metrics data for one or more of the plurality of performance metrics; determining, at a coordinator communicatively connected to the plurality of collectors and the plurality of aggregators, whether the hash ring has changed; and communicating, at the coordinator, information on the determined change to the plurality of collectors.

The method can be implemented in various ways to include one or more of the following features. For example, the information can indicate that one of the plurality of aggregators has been removed or a new aggregator has been added. The method can include redistributing, by the collectors, the received time series metrics data based on the information. The redistributing can include forwarding the received time series metrics data for the one or more of the plurality of performance metrics assigned to the removed aggregator to next aggregator in the hash ring starting from next data point (in time series) after removing the aggregator. The method can include accumulating the time series metrics data for the one or more of the plurality of performance metrics assigned to the removed aggregator received at the removed aggregator before removing the aggregator to obtain an accumulated value for the removed aggregator; and accumulating the time series metrics data for the one or more of the plurality of performance metrics assigned to the removed aggregator received at the next aggregator after removing the aggregator to obtain an accumulated value for the next aggregator. The method can include writing, to a database, the accumulated value for the removed aggregator obtained from the time series metrics data received at the removed aggregator before removing the aggregator; and writing, to the database, the accumulated value for the next aggregator obtained from the time series metrics data received at the next aggregator after removing the aggregator. The method can include merging the two accumulated values to perform a time roll up for a time period. The redistributing can include forwarding the received time series metrics data for the one or more of the plurality of performance metrics assigned to one of the plurality of aggregator to the newly added aggregator in the consistent hash ring starting from next data point after adding the new aggregator. The method can include accumulating the time series metrics data for the one or more of the plurality of performance metrics assigned to one of the aggregators received at the one of the aggregators before adding the new aggregator to obtain an accumulated value for the one or the aggregators; and accumulating the time series metrics data for the one or more of the plurality of performance metrics assigned to the one of the aggregators received at the newly added aggregator after adding the aggregator to obtain an accumulated value for the new aggregator. The method can include writing, to a database, the accumulated value for the one of the aggregators obtained from the time series metrics data received at the one of the aggregators before adding the aggregator; and writing, to the database, the accumulated value for the newly added aggregator obtained from the time series metrics data received at the newly added aggregator after adding the newly added aggregator. The method can include merging the two accumulated values to perform a time roll up for a time period.

In yet another aspect, a non-transitory computer readable medium embodying instructions is disclosed. When the instructions are executed by a processor, the instructions can cause operations to be performed including: receiving, at a plurality of collectors, time series metrics data for a plurality of performance metrics from one or more agents instrumented into monitored applications; aggregating, at a plurality of aggregators communicatively connected to the collectors to form a consistent hash ring, the received time series metrics data for the plurality of performance metrics, wherein each aggregator is assigned to aggregate all received time series metrics data for one or more of the plurality of performance metrics; determining, at a coordinator communicatively connected to the plurality of collectors and the plurality of aggregators, whether one of the plurality of the aggregators in the hash ring has crashed; and performing a repair job to fix data corruption caused by the crashed aggregator.

The non-transitory computer readable medium can be implemented to include one or more of the following features. For example, the operations can include redistributing the received time series metrics data for the one or more of the plurality of performance metrics assigned to the crashed aggregator to next aggregator in the hash ring. Performing the repair job can include obtaining the time series metrics data received at the crashed aggregator before the crash; and merging the obtained time series metric data from the crashed aggregator with the time series metrics data redistributed to the next aggregator in the hash ring. The operations can include splitting the time series metrics data received at the crashed aggregator before the crash into smaller time series.

The components shown in FIG. 12 are depicted as being connected via a single bus 1290. However, the components may be connected through one or more data transport means. For example, processor unit 1210 and main memory 1220 may be connected via a local microprocessor bus, and the mass storage device 1230, peripheral device(s) 1280, portable or remote storage device 1240, and display system 1270 may be connected via one or more input/output (I/O) buses.

Mass storage device 1230, which may be implemented with a magnetic disk drive or an optical disk drive, is a non-volatile storage device for storing data and instructions for use by processor unit 1210. Mass storage device 1230 can store the system software for implementing embodiments of the present invention for purposes of loading that software into main memory 620.

Portable storage device 1240 operates in conjunction with a portable non-volatile storage medium, such as a compact disk, digital video disk, magnetic disk, flash storage, etc. to input and output data and code to and from the computer system 1200 of FIG. 12. The system software for implementing embodiments of the present invention may be stored on such a portable medium and input to the computer system 1200 via the portable storage device 1240.

Input devices 1260 provide a portion of a user interface. Input devices 1260 may include an alpha-numeric keypad, such as a keyboard, for inputting alpha-numeric and other information, or a pointing device, such as a mouse, a trackball, stylus, or cursor direction keys. Additionally, the system 1200 as shown in FIG. 12 includes output devices 1250. Examples of suitable output devices include speakers, printers, network interfaces, and monitors.

Display system 1270 may include a liquid crystal display (LCD) or other suitable display device. Display system 1270 receives textual and graphical information, and processes the information for output to the display device.

Peripherals 1280 may include any type of computer support device to add additional functionality to the computer system. For example, peripheral device(s) 1280 may include a modem or a router.

The components contained in the computer system 1200 of FIG. 12 can include a personal computer, hand held computing device, telephone, mobile computing device, workstation, server, minicomputer, mainframe computer, or any other computing device. The computer can also include different bus configurations, networked platforms, multi-processor platforms, etc. Various operating systems can be used including Unix, Linux, Windows, Apple OS, and other suitable operating systems, including mobile versions.

When implementing a mobile device such as smart phone or tablet computer, the computer system 1200 of FIG. 12 may include one or more antennas, radios, and other circuitry for communicating over wireless signals, such as for example communication using Wi-Fi, cellular, or other wireless signals.

While this patent document contains many specifics, these should not be construed as limitations on the scope of any invention or of what may be claimed, but rather as descriptions of features that may be specific to particular embodiments of particular inventions. Certain features that are described in this patent document in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination. Moreover, although features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a subcombination or variation of a subcombination.

Similarly, while operations are depicted in the drawings in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results. Moreover, the separation of various system components in the embodiments described in this patent document should not be understood as requiring such separation in all embodiments.

Only a few implementations and examples are described and other implementations, enhancements and variations can be made based on what is described and illustrated in this patent document. 

What is claimed is:
 1. A method for metric payloads ingestion and playback, the method including: receiving, by a collector executing on a server, time series of metric payloads for a plurality of performance metrics indicating performance of a node or machine, wherein the collector is communicatively connected to a coordinator that provides collectors with information on a plurality of aggregators including assignments of the performance metrics to each aggregator; storing, by a database executing on the server, the received time series of metric payloads in a payload tracking table of a database, wherein the storing includes: storing the received time series of metric payloads in different layers and partitioned regions of the payload tracking table, wherein the layers represent time ranges corresponding to time points when the time series of metric payloads are received, and wherein the partitioned regions are assigned to received certain ones of the received time series of metric payloads; and replaying the stored time series of metric payloads from a select one or more of the partitioned region or layer or both.
 2. The method of claim 1, including: receiving a request to replay the stored time series of metric payloads for a specific one of the layers; and performing the replaying for the specific one of the layers based on the received request to replay.
 3. The method of claim 2, wherein the received request to replay is associated with a repair job to repair data corruption.
 4. The method of claim 3, wherein the specific one of the layers represent a time range associated with the data corruption.
 5. The method of claim 3, including: outputting a result of the replay to the repair job.
 6. The method of claim 5, including: performing the repair job using the outputted result.
 7. The method of claim 1, including: outputting a result of the replay.
 8. The method of claim 1, wherein the partitioned regions are created using a hash function.
 9. The method of claim 1, wherein the database includes HBase.
 10. A system for metric payload data ingestion and playback, the system including: a plurality of collectors executed by one or more processors on one or more servers in a computer network and configured to receive time series metric payloads for a plurality of performance metrics from one or more agents instrumented into monitored applications; a plurality of aggregators executed by the one or more processors on the one or more servers in the computer network and communicatively connected to the collectors and configured to aggregate the received time series metric payloads for the plurality of performance metrics, wherein each aggregator is assigned to aggregate all received time series metric payloads for one or more of the plurality of performance metrics; a coordinator executed by the one or more processors on the one or more servers in the computer network and communicatively connected to the plurality of collectors and plurality of aggregators and configured to provide collectors with information on the plurality of aggregators including assignments of the performance metrics to each aggregator; and a database executed by the one or more processors on the one or more servers in the computer network and including a payload tracking table for storing the received time series metric payloads.
 11. The system of claim 10, wherein the payload tracking table includes: different layers having partitioned regions, wherein the layers represent time ranges corresponding to time points when the time series of metric payloads are received, and wherein the partitioned regions are assigned to received certain ones of the received time series of metric payloads.
 12. The system of claim 10, wherein the payload tracking table is configured to replay the stored time series of metric payloads from a select one or more of the partitioned region or layer or both.
 13. The system of claim 12, wherein the payload tracking table is configured to replay the stored time series of metric payloads responsive to a request to replay the stored time series of metric payloads for a specific one of the layers.
 14. The system of claim 13, wherein the request to replay is associated with a repair job to repair data corruption.
 15. The system of claim 14, wherein the specific one of the layers represent a time range associated with the data corruption.
 16. The system of claim 10, wherein the partitioned regions are created using a hash function.
 17. The system of claim 10, wherein the database includes HBase.
 18. A non-transitory computer readable medium embodying instructions when executed by a processor to cause operations to be performed including: receiving time series of metric payloads for a plurality of performance metrics indicating performance of a node or machine, wherein the collector is communicatively connected to a coordinator that provides collectors with information on a plurality of aggregators including assignments of the performance metrics to each aggregator; storing the received time series of metric payloads in a payload tracking table of a database, wherein the storing includes: storing the received time series of metric payloads in different layers and partitioned regions of the payload tracking table, wherein the layers represent time ranges corresponding to time points when the time series of metric payloads are received, and wherein the partitioned regions are assigned to received certain ones of the received time series of metric payloads; and replaying the stored time series of metric payloads from a select one or more of the partitioned region or layer or both.
 19. The non-transitory computer readable medium of claim 18, wherein the operations include: receiving a request to replay the stored time series of metric payloads for a specific one of the layers; and performing the replaying for the specific one of the layers based on the received request to replay.
 20. The non-transitory computer readable medium of claim 19, wherein the received request to replay is associated with a repair job to repair data corruption.
 21. The non-transitory computer readable medium of claim 20, wherein the specific one of the layers represent a time range associated with the data corruption. 